const math/big._W

87 uses

	math/big (current package)
		arith.go#L19: 	_S = _W / 8 // word size in bytes
		arith.go#L21: 	_W = bits.UintSize // word size in bits
		arith.go#L22: 	_B = 1 << _W       // digit base
		arith.go#L154: 	s &= _W - 1 // hint to the compiler that shifts by s don't need guard code
		arith.go#L155: 	ŝ := _W - s
		arith.go#L156: 	ŝ &= _W - 1 // ditto
		arith.go#L177: 	s &= _W - 1 // hint to the compiler that shifts by s don't need guard code
		arith.go#L178: 	ŝ := _W - s
		arith.go#L179: 	ŝ &= _W - 1 // ditto
		arith.go#L214: 		x1 = x1<<s | x0>>(_W-s)
		decimal.go#L42: const maxShift = _W - 4
		float.go#L219: 	return uint(len(x.mant))*_W - x.mant.trailingZeroBits()
		float.go#L381: 	const msb = 1 << (_W - 1)
		float.go#L413: 	bits := m * _W           // present mantissa bits; bits > 0
		float.go#L443: 	n := (z.prec + (_W - 1)) / _W // mantissa length in words for desired precision
		float.go#L450: 	ntz := n*_W - z.prec // 0 <= ntz < _W
		float.go#L494: 				const msb = 1 << (_W - 1)
		float.go#L702: 	if debugFloat && x[i]&(1<<(_W-1)) == 0 {
		float.go#L705: 	switch _W {
		float.go#L720: 	if debugFloat && x[i]&(1<<(_W-1)) == 0 {
		float.go#L723: 	switch _W {
		float.go#L878: 			if p < 0 /* m <= 0.25 */ || p == 0 && x.mant.sticky(uint(len(x.mant))*_W-1) == 0 /* m == 0.5 */ {
		float.go#L998: 			if p < 0 /* m <= 0.25 */ || p == 0 && x.mant.sticky(uint(len(x.mant))*_W-1) == 0 /* m == 0.5 */ {
		float.go#L1103: 		allBits := uint(len(x.mant)) * _W
		float.go#L1150: 		allBits := int32(len(x.mant)) * _W
		float.go#L1229: 	ex := int64(x.exp) - int64(len(x.mant))*_W
		float.go#L1230: 	ey := int64(y.exp) - int64(len(y.mant))*_W
		float.go#L1260: 	z.setExpAndRound(ex+int64(len(z.mant))*_W-fnorm(z.mant), 0)
		float.go#L1276: 	ex := int64(x.exp) - int64(len(x.mant))*_W
		float.go#L1277: 	ey := int64(y.exp) - int64(len(y.mant))*_W
		float.go#L1313: 	z.setExpAndRound(ex+int64(len(z.mant))*_W-fnorm(z.mant), 0)
		float.go#L1350: 	n := int(z.prec/_W) + 1
		float.go#L1370: 	e := int64(x.exp) - int64(y.exp) - int64(d-len(z.mant))*_W
		floatconv.go#L85: 	exp2 := int64(len(z.mant))*_W - fnorm(z.mant)
		floatmarsh.go#L31: 		n = int((x.prec + (_W - 1)) / _W) // required mantissa length in words for given precision
		ftoa.go#L330: 	switch w := uint32(len(x.mant)) * _W; {
		ftoa.go#L381: 	switch w := uint(len(x.mant)) * _W; {
		int.go#L87: 	} else if _W == 32 && u>>32 != 0 {
		int.go#L417: 	if _W == 32 && len(x) > 1 {
		int.go#L441: 	if len(x.abs) <= 64/_W {
		int.go#L450: 	return !x.neg && len(x.abs) <= 64/_W
		int.go#L671: 	a1 = A.abs[n-1]<<h | A.abs[n-2]>>(_W-h)
		int.go#L675: 		a2 = B.abs[n-1]<<h | B.abs[n-2]>>(_W-h)
		int.go#L677: 		a2 = B.abs[n-2] >> (_W - h)
		nat.go#L678: 		return i*_W + bits.Len(top)
		nat.go#L694: 	return i*_W + uint(bits.TrailingZeros(uint(x[i])))
		nat.go#L704: 		return i*_W + uint(bits.TrailingZeros(uint(x[i]))), true
		nat.go#L730: 	n := m + int(s/_W)
		nat.go#L732: 	z[n] = shlVU(z[n-m:n], x, s%_W)
		nat.go#L750: 	n := m - int(s/_W)
		nat.go#L757: 	shrVU(z, x[m-n:], s%_W)
		nat.go#L763: 	j := int(i / _W)
		nat.go#L764: 	m := Word(1) << (i % _W)
		nat.go#L793: 	j := i / _W
		nat.go#L798: 	return uint(x[j] >> (i % _W) & 1)
		nat.go#L804: 	j := i / _W
		nat.go#L817: 	if x[j]<<(_W-i%_W) != 0 {
		nat.go#L841: 	w := (n + _W - 1) / _W
		nat.go#L847: 	if n%_W != 0 {
		nat.go#L848: 		z[len(z)-1] &= 1<<(n%_W) - 1
		nat.go#L916: 	bitLengthOfMSW := uint(n % _W)
		nat.go#L918: 		bitLengthOfMSW = _W
		nat.go#L923: 		switch _W {
		nat.go#L1011: 	const mask = 1 << (_W - 1)
		nat.go#L1017: 	w := _W - int(shift)
		nat.go#L1041: 		for j := 0; j < _W; j++ {
		nat.go#L1128: 	w := int((logM + _W - 1) / _W)
		nat.go#L1154: 	mtop := int((logM - 2) / _W) // -2 because the top word of N bits is the (N-1)/W'th word.
		nat.go#L1156: 	if mbits := (logM - 1) & (_W - 1); mbits != 0 {
		nat.go#L1169: 		for j := 0; j < _W; j += n {
		nat.go#L1192: 			zz = zz.mul(z, *powers[yi>>(_W-n)])
		nat.go#L1232: 	for i := 1; i < _W; i <<= 1 {
		nat.go#L1240: 	zz := nat(nil).shl(RR, uint(2*numWords*_W))
		nat.go#L1269: 		for j := 0; j < _W; j += n {
		nat.go#L1276: 			zz = zz.montgomery(z, powers[yi>>(_W-n)], m, k0, numWords)
		nat.go#L1336: 	if _W == 64 {
		nat.go#L1421: 	for uint(len(z))*_W < n {
		natconv.go#L287: 		nbits := uint(_W) // number of unprocessed bits in w
		natconv.go#L303: 				nbits = _W
		natconv.go#L312: 				nbits = _W - (shift - nbits)
		prime.go#L61: 	switch _W {
		sqrt.go#L128: 	z.mant = z.mant.make(int(prec2/_W) * 2)